/*
 * Auto generated C++ implementation for Mass Effect 2.
 *	by _silencer.
 */

#include "stdafx.h"
#include "unreal_game.h"

namespace game
{
	IMPLEMENT_PACKAGE_CLASS( ActorFactoryWwiseAmbientSound, ActorFactory, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( AnimNotify_WwiseEvent, AnimNotify, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( InterpTrackInstWwiseEvent, InterpTrackInst, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( InterpTrackInstWwiseRTPC, InterpTrackInst, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( InterpTrackWwiseEvent, InterpTrack, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( InterpTrackWwiseRTPC, InterpTrackFloatBase, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( InterpTrackWwiseSoundEffect, InterpTrackWwiseEvent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseClearBanks, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseLoadBank, SeqAct_Latent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseLockMic, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseMusicVolumeDisable, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseMusicVolumeEnable, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwisePostEvent, SeqAct_Latent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwisePostTrigger, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseSetRTPCValue, SeqAct_Latent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseSetState, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseSetSwitch, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseStartAudioObjects, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( SeqAct_WwiseStopAll, SequenceAction, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseAudioComponent, ActorComponent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseAmbientSound, Keypoint, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseAudioComponentMultiLoc, WwiseAudioComponent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseAudioDevice, AudioDevice, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseVolume, Volume, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseAudioVolume, WwiseVolume, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseBank, Object, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseEvent, WwiseBaseSoundObject, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseCollection, Object, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseComponentCallback, Interface, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseDialogueEvent, WwiseEvent, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseEnvironmentSettings, Object, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseEnvironmentVolume, Volume, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseEventPairObject, WwiseBaseSoundObject, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseEventInstance, WwiseEventPairObject, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseFaceFXStopper, Object, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseMicPosOrient, Actor, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseMusicVolume, WwiseVolume, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseStream, Object, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseVolumeTimer, Info, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( ActorFactoryWwiseDistanceRTPC, ActorFactory, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseDistanceRTPC, Actor, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( ActorFactoryWwiseMicPosOrient, ActorFactory, WwiseAudio )
	IMPLEMENT_PACKAGE_CLASS( WwiseOcclusionVolume, Volume, WwiseAudio )


	void WwiseAudioComponent::SetLocation( Vector NewLocation )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetLocation" );

		struct SetLocationParams
		{
			Vector NewLocation; //offset = 0, size = 12
		} params;

		params.NewLocation = NewLocation;

		this->call_function( function, &params, 0 );
	}

	void WwiseAudioComponent::Set3D()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.Set3D" );

		this->call_function( function, 0, 0 );
	}

	void WwiseAudioComponent::Set2D()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.Set2D" );

		this->call_function( function, 0, 0 );
	}

	Bool WwiseAudioComponent::RegisterGameObject()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.RegisterGameObject" );

		struct RegisterGameObjectParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::UnregisterGameObject()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.UnregisterGameObject" );

		struct UnregisterGameObjectParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float WwiseAudioComponent::GetDistanceToListener()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.GetDistanceToListener" );

		struct GetDistanceToListenerParams
		{
			Float ReturnValue; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void WwiseAudioComponent::SetObstructionOcclusionEnabled( Bool i_bValue )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetObstructionOcclusionEnabled" );

		struct SetObstructionOcclusionEnabledParams
		{
			Bool i_bValue: 1; //offset = 0, size = 4
		} params;

		params.i_bValue = i_bValue;

		this->call_function( function, &params, 0 );
	}

	void WwiseAudioComponent::SetEnvironmentalAudioEnabled( Bool i_bValue )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetEnvironmentalAudioEnabled" );

		struct SetEnvironmentalAudioEnabledParams
		{
			Bool i_bValue: 1; //offset = 0, size = 4
		} params;

		params.i_bValue = i_bValue;

		this->call_function( function, &params, 0 );
	}

	Bool WwiseAudioComponent::GetObstructionOcclusionEnabled()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.GetObstructionOcclusionEnabled" );

		struct GetObstructionOcclusionEnabledParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::GetEnvironmentalAudioEnabled()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.GetEnvironmentalAudioEnabled" );

		struct GetEnvironmentalAudioEnabledParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector WwiseAudioComponent::GetMicPosition()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.GetMicPosition" );

		struct GetMicPositionParams
		{
			Vector ReturnValue; //offset = 0, size = 12
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::SetGlobalRTPCFromScript( String in_pszRtpcName, Float in_value )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetGlobalRTPCFromScript" );

		struct SetGlobalRTPCFromScriptParams
		{
			String in_pszRtpcName; //offset = 0, size = 12
			Float in_value; //offset = 12, size = 4
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.in_pszRtpcName = in_pszRtpcName;
		params.in_value = in_value;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	WwiseAudioComponent* WwiseAudioComponent::CreateComponentFromScript( Actor* pActor, String Label, Name ComponentGroup, Name AttachBone, Bool bRegister )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.CreateComponentFromScript" );

		struct CreateComponentFromScriptParams
		{
			Actor* pActor; //offset = 0, size = 4
			String Label; //offset = 4, size = 12
			Name ComponentGroup; //offset = 16, size = 8
			Name AttachBone; //offset = 24, size = 8
			Bool bRegister: 1; //offset = 32, size = 4
			WwiseAudioComponent* ReturnValue; //offset = 36, size = 4
		} params;

		params.pActor = pActor;
		params.Label = Label;
		params.ComponentGroup = ComponentGroup;
		params.AttachBone = AttachBone;
		params.bRegister = bRegister;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::IsEventPlaying( Int Index )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.IsEventPlaying" );

		struct IsEventPlayingParams
		{
			Int Index; //offset = 0, size = 4
			Bool ReturnValue: 1; //offset = 4, size = 4
		} params;

		params.Index = Index;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::IsPlaying( WwiseBaseSoundObject* Event )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.IsPlaying" );

		struct IsPlayingParams
		{
			WwiseBaseSoundObject* Event; //offset = 0, size = 4
			Bool ReturnValue: 1; //offset = 4, size = 4
		} params;

		params.Event = Event;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::PostGlobalEvent( Name GlobalEventName )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.PostGlobalEvent" );

		struct PostGlobalEventParams
		{
			Name GlobalEventName; //offset = 0, size = 8
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.GlobalEventName = GlobalEventName;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::SetWwiseTrigger( String sTrigger )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetWwiseTrigger" );

		struct SetWwiseTriggerParams
		{
			String sTrigger; //offset = 0, size = 12
			Bool ReturnValue: 1; //offset = 12, size = 4
		} params;

		params.sTrigger = sTrigger;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::SetWwiseSwitch( String sGroup, String sState )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetWwiseSwitch" );

		struct SetWwiseSwitchParams
		{
			String sGroup; //offset = 0, size = 12
			String sState; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.sGroup = sGroup;
		params.sState = sState;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::SetWwiseRTPC( String sName, Float fValue )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetWwiseRTPC" );

		struct SetWwiseRTPCParams
		{
			String sName; //offset = 0, size = 12
			Float fValue; //offset = 12, size = 4
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.sName = sName;
		params.fValue = fValue;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::Stop( WwiseBaseSoundObject* Base )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.Stop" );

		struct StopParams
		{
			WwiseBaseSoundObject* Base; //offset = 0, size = 4
			Bool ReturnValue: 1; //offset = 4, size = 4
		} params;

		params.Base = Base;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::StopWwiseEvent( WwiseEventPair AudioEvent )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.StopWwiseEvent" );

		struct StopWwiseEventParams
		{
			WwiseEventPair AudioEvent; //offset = 0, size = 8
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.AudioEvent = AudioEvent;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::Play( WwiseBaseSoundObject* Base, Bool bTrackPosition )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.Play" );

		struct PlayParams
		{
			WwiseBaseSoundObject* Base; //offset = 0, size = 4
			Bool bTrackPosition: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.Base = Base;
		params.bTrackPosition = bTrackPosition;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::PlayWwiseEvent( WwiseEventPair AudioEvent, Bool bTrackPosition )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.PlayWwiseEvent" );

		struct PlayWwiseEventParams
		{
			WwiseEventPair AudioEvent; //offset = 0, size = 8
			Bool bTrackPosition: 1; //offset = 8, size = 4
			Bool ReturnValue: 1; //offset = 12, size = 4
		} params;

		params.AudioEvent = AudioEvent;
		params.bTrackPosition = bTrackPosition;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float WwiseAudioComponent::InstancePosition( Int Index )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.InstancePosition" );

		struct InstancePositionParams
		{
			Int Index; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.Index = Index;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::StopAll()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.StopAll" );

		struct StopAllParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::StopInstance( Int Index )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.StopInstance" );

		struct StopInstanceParams
		{
			Int Index; //offset = 0, size = 4
			Bool ReturnValue: 1; //offset = 4, size = 4
		} params;

		params.Index = Index;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool WwiseAudioComponent::PlayInstance( Int Index, Bool bTrackPosition )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.PlayInstance" );

		struct PlayInstanceParams
		{
			Int Index; //offset = 0, size = 4
			Bool bTrackPosition: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.Index = Index;
		params.bTrackPosition = bTrackPosition;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int WwiseAudioComponent::FindInstanceIndex( WwiseBaseSoundObject* BaseSound, WwiseEvent* StopEvent )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.FindInstanceIndex" );

		struct FindInstanceIndexParams
		{
			WwiseBaseSoundObject* BaseSound; //offset = 0, size = 4
			WwiseEvent* StopEvent; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.BaseSound = BaseSound;
		params.StopEvent = StopEvent;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int WwiseAudioComponent::AddInstance( WwiseBaseSoundObject* BaseSound, WwiseEvent* StopEvent )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.AddInstance" );

		struct AddInstanceParams
		{
			WwiseBaseSoundObject* BaseSound; //offset = 0, size = 4
			WwiseEvent* StopEvent; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.BaseSound = BaseSound;
		params.StopEvent = StopEvent;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void WwiseAudioComponent::SetRTPCWithHandler( WwiseRTPCForActorHandler RTPCHandler, Float fValue )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponent.SetRTPCWithHandler" );

		struct SetRTPCWithHandlerParams
		{
			WwiseRTPCForActorHandler RTPCHandler; //offset = 0, size = 20
			Float fValue; //offset = 20, size = 4
		} params;

		params.RTPCHandler = RTPCHandler;
		params.fValue = fValue;

		this->call_function( function, &params, 0 );
	}

	void WwiseAudioComponentMultiLoc::Set3D()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioComponentMultiLoc.Set3D" );

		this->call_function( function, 0, 0 );
	}

	void WwiseVolume::TimerPop( WwiseVolumeTimer* T )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseVolume.TimerPop" );

		struct TimerPopParams
		{
			WwiseVolumeTimer* T; //offset = 0, size = 4
		} params;

		params.T = T;

		this->call_function( function, &params, 0 );
	}

	void WwiseVolume::PostBeginPlay()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseVolume.PostBeginPlay" );

		this->call_function( function, 0, 0 );
	}

	void WwiseAudioVolume::Stop()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.Stop" );

		this->call_function( function, 0, 0 );
	}

	void WwiseAudioVolume::Start()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.Start" );

		this->call_function( function, 0, 0 );
	}

	void WwiseAudioVolume::myTimerPop()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.myTimerPop" );

		this->call_function( function, 0, 0 );
	}

	void WwiseAudioVolume::TimerPop( WwiseVolumeTimer* T )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.TimerPop" );

		struct TimerPopParams
		{
			WwiseVolumeTimer* T; //offset = 0, size = 4
		} params;

		params.T = T;

		this->call_function( function, &params, 0 );
	}

	void WwiseAudioVolume::UnTouch( Actor* Other )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.UnTouch" );

		struct UnTouchParams
		{
			Actor* Other; //offset = 0, size = 4
		} params;

		params.Other = Other;

		this->call_function( function, &params, 0 );
	}

	void WwiseAudioVolume::Touch( Actor* Other, PrimitiveComponent* OtherComp, Vector HitLocation, Vector HitNormal )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.Touch" );

		struct TouchParams
		{
			Actor* Other; //offset = 0, size = 4
			PrimitiveComponent* OtherComp; //offset = 4, size = 4
			Vector HitLocation; //offset = 8, size = 12
			Vector HitNormal; //offset = 20, size = 12
		} params;

		params.Other = Other;
		params.OtherComp = OtherComp;
		params.HitLocation = HitLocation;
		params.HitNormal = HitNormal;

		this->call_function( function, &params, 0 );
	}

	void WwiseAudioVolume::PostBeginPlay()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseAudioVolume.PostBeginPlay" );

		this->call_function( function, 0, 0 );
	}

	Vector WwiseMicPosOrient::GetUpVector()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMicPosOrient.GetUpVector" );

		struct GetUpVectorParams
		{
			Vector ReturnValue; //offset = 0, size = 12
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector WwiseMicPosOrient::GetFrontVector()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMicPosOrient.GetFrontVector" );

		struct GetFrontVectorParams
		{
			Vector ReturnValue; //offset = 0, size = 12
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void WwiseMusicVolume::myTimerPop()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.myTimerPop" );

		this->call_function( function, 0, 0 );
	}

	void WwiseMusicVolume::SetContainsPlayer( Bool bContainsPlayer )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.SetContainsPlayer" );

		struct SetContainsPlayerParams
		{
			Bool bContainsPlayer: 1; //offset = 0, size = 4
		} params;

		params.bContainsPlayer = bContainsPlayer;

		this->call_function( function, &params, 0 );
	}

	void WwiseMusicVolume::SetEnabled( Bool bEnabled )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.SetEnabled" );

		struct SetEnabledParams
		{
			Bool bEnabled: 1; //offset = 0, size = 4
		} params;

		params.bEnabled = bEnabled;

		this->call_function( function, &params, 0 );
	}

	void WwiseMusicVolume::StopMusic()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.StopMusic" );

		this->call_function( function, 0, 0 );
	}

	void WwiseMusicVolume::StartMusic()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.StartMusic" );

		this->call_function( function, 0, 0 );
	}

	Bool WwiseMusicVolume::CheckPriority()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.CheckPriority" );

		struct CheckPriorityParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void WwiseMusicVolume::TimerPop( WwiseVolumeTimer* T )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.TimerPop" );

		struct TimerPopParams
		{
			WwiseVolumeTimer* T; //offset = 0, size = 4
		} params;

		params.T = T;

		this->call_function( function, &params, 0 );
	}

	void WwiseMusicVolume::PostBeginPlay()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseMusicVolume.PostBeginPlay" );

		this->call_function( function, 0, 0 );
	}

	void WwiseVolumeTimer::Timer()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseVolumeTimer.Timer" );

		this->call_function( function, 0, 0 );
	}

	void WwiseDistanceRTPC::Tick( Float DeltaTime, Float DistanceFromListener, Vector Distance, Vector MicPosition )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function WwiseAudio.WwiseDistanceRTPC.Tick" );

		struct TickParams
		{
			Float DeltaTime; //offset = 0, size = 4
			Float DistanceFromListener; //offset = 4, size = 4
			Vector Distance; //offset = 8, size = 12
			Vector MicPosition; //offset = 20, size = 12
		} params;

		params.DeltaTime = DeltaTime;
		params.DistanceFromListener = DistanceFromListener;
		params.Distance = Distance;
		params.MicPosition = MicPosition;

		this->call_function( function, &params, 0 );
	}
}
